import requests
import logging
import concurrent.futures
from openai import OpenAI
import time
import re  # 添加正则表达式模块

logger = logging.getLogger(__name__)

class FineTuningService:
    """
    笔记优化服务类，通过调用硅基流动微调后的大模型API提供笔记优化功能
    支持流式输出模式，为大学生提供专业的笔记优化服务
    
    专业定位：
    1. 学科专家身份定位 - 根据不同学科，AI会以该领域专家角色提供专业辅导
    2. 知识点深度解析 - 对笔记内容进行深度剖析、补充与扩展
    3. 考试重点标注 - 自动标记考试常见考点和易错点(⭐标识)
    4. 概念精准诠释 - 提供学术精准的概念解释和理论框架
    5. 结构化呈现 - 使用标题层级、要点列表等结构化方式组织内容
    6. 应用场景关联 - 适时补充知识点的实际应用场景和例子
    
    核心功能：
    1. 笔记内容丰富与补充(enrich) - 完善笔记中的知识点，补充缺失要点
    2. 知识点扩展与深度解析(expand) - 对重要概念进行深度扩展和多维分析
    """
    def __init__(self):
        """
        初始化笔记优化服务
        """
        # 硅基流动API配置
        self.api_key = "sk-aurchqbefvggyopfdwtydaqgonwgzswmskpeungikhvfvcpq"
        if not self.api_key:
            logger.warning("未设置SILICONFLOW_API_KEY")
        
        self.api_url = "https://api.siliconflow.cn/v1"

        # 使用领域大模型
        self.model_name = "ft:LoRA/Qwen/Qwen2.5-72B-Instruct:secotlme77:note_optimize-v3:psqdhjadrtqcdckqifzo-ckpt_step_5"
        self._current_note_content = ""  # 初始化存储当前笔记内容的属性
        
        # 初始化OpenAI客户端
        self.client = OpenAI(
            api_key=self.api_key,
            base_url=self.api_url
        )
        
        # 配置请求会话和并发设置
        self.session = requests.Session()
        self.session.headers.update({
            "Authorization": f"Bearer {self.api_key}",
            "Content-Type": "application/json",
            "Accept": "application/json"
        })
        
        # 配置请求会话的连接池
        adapter = requests.adapters.HTTPAdapter(
            pool_connections=20,  # 增加连接池大小
            pool_maxsize=30,  # 增加最大连接数
            max_retries=5,  # 增加重试次数
            pool_block=False  # 不阻塞连接池
        )
        self.session.mount('https://', adapter)
        
        # 设置最大工作线程数
        self.max_workers = 12  # 增加线程数以提高并发处理能力
        # 线程池，用于并发处理
        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=self.max_workers)
        
        # 添加健康检查标志
        self.is_healthy = True
        self.last_health_check = 0
        self.health_check_interval = 3600  # 每小时检查一次
        
    def optimize_note(self, note_content, task_type='enrich', subject_area=None, stream=True, note_title=None):
        """优化笔记内容
        
        参数:
            note_content: 笔记内容
            task_type: 任务类型 - enrich(完善笔记) 或 expand(拓展要点)
            subject_area: 学科领域
            stream: 是否流式输出
            note_title: 笔记标题
            
        返回:
            优化后的内容
        """
        # 验证任务类型
        if task_type not in ['enrich', 'expand']:
            logger.warning(f"无效的任务类型: {task_type}，使用默认值'enrich'")
            task_type = 'enrich'
        
        # 检测笔记学科领域
        if not subject_area and note_title:
            detected_subject = self._detect_subject_area(note_content, note_title)
            if detected_subject:
                subject_area = detected_subject
                logger.info(f"基于标题和内容推断学科领域: {subject_area}")
        
        # 获取系统提示词
        system_prompt = self._get_system_prompt(task_type)
        
        # 如果有学科领域，增强系统提示词
        if subject_area:
            subject_expertise = self._get_subject_expertise(subject_area)
            subject_specific_prompts = self._get_subject_specific_prompts(subject_area, task_type)
            if subject_specific_prompts:
                enhanced_prompt = f"{system_prompt}\n\n作为{subject_expertise}，{subject_specific_prompts}"
                system_prompt = enhanced_prompt
        
        # 构建用户提示词
        user_prompt = self._create_prompt_for_note_organization(note_content, task_type, subject_area, note_title)
        
        # 调用API进行处理
        try:
            if stream:
                # 流式处理
                content_blocks = []
                for content_chunk in self._stream_api_call_openai(system_prompt, user_prompt):
                    content_blocks.append(content_chunk)
                    yield content_chunk
                
                # 流式处理结束后，处理完整内容并返回
                complete_content = ''.join(content_blocks)
                cleaned_content = self._post_process_content(complete_content)
                
                # 返回处理结果
                yield {
                    "complete": True,
                    "optimized_content": cleaned_content,
                    "task_type": task_type,
                    "subject": subject_area or "未指定"
                }
            else:
                # 非流式处理
                content = self._call_api(system_prompt, user_prompt)
                cleaned_content = self._post_process_content(content)
                return cleaned_content
                
        except Exception as e:
            error_msg = f"优化笔记内容失败: {str(e)}"
            logger.error(error_msg)
            if stream:
                yield {"error": error_msg}
            else:
                raise Exception(error_msg)

    def _get_system_prompt(self, task_type):
        """获取系统提示词"""
        if task_type == 'enrich':
            return """你是一位专业的大学学习助手，擅长帮助大学生完善笔记内容。请对提供的笔记进行系统化的补充和完善，使其更加全面、准确和有深度。保留原有内容和结构，添加必要的解释、例子、公式和相关知识。确保内容符合大学学术水平，便于理解和记忆。

核心提示：
1. 识别笔记中的核心概念，并补充准确、完整的学术定义
2. 对重要概念添加详细解释，确保概念之间的逻辑关系清晰
3. 补充相关的理论背景和关键公式，使用标准数学表达方式
4. 添加适当的例子和应用场景，帮助理解抽象概念
5. 使用专业术语，保持学术严谨性
6. 对重点内容和易错点使用标记强调，便于复习
7. 保持内容的结构化和条理性，使用适当的标题和小标题

输出规范要求：
- 直接输出笔记内容，不要添加任何引言、总结或对话式语句
- 不要使用"对于大学生来说"、"建议通过"等表述
- 不要在内容结尾添加"希望对你有帮助"等总结语
- 保持专业学术风格，避免口语化表达
- 内容应该是一份独立完整的学习材料，而非对话回复"""
        elif task_type == 'expand':
            return """你是一位专业的大学学习助手，擅长基于笔记要点进行知识拓展。请对提供的笔记要点进行系统性的知识拓展和深入讲解，提供详细解释、理论基础和应用场景。使用符合大学水平的专业表达，既学术准确又便于理解。

核心提示：
1. 深入分析核心概念的内涵和外延，揭示其本质特征
2. 建立概念间的理论联系，形成系统化的知识网络
3. 探讨理论的发展脉络和学术争议，展示学科前沿
4. 分析实际应用场景和案例，展示理论的实践价值
5. 对比相关理论和方法的异同，培养批判性思维
6. 提供多角度的思考路径和分析框架
7. 补充相关研究方法和学术规范

输出规范要求：
- 直接输出笔记内容，不要添加任何引言、总结或对话式语句
- 不要使用"对于大学生来说"、"建议通过"等表述
- 不要在内容结尾添加"希望对你有帮助"等总结语
- 保持专业学术风格，避免口语化表达
- 内容应该是一份独立完整的学习材料，而非对话回复"""
        else:
            return """你是一位专业的大学学习助手，擅长处理和优化学术笔记。请根据任务需求处理提供的笔记，保持专业性和学术准确性。

输出规范要求：
- 直接输出笔记内容，不要添加任何引言、总结或对话式语句
- 不要使用"对于大学生来说"、"建议通过"等表述
- 不要在内容结尾添加"希望对你有帮助"等总结语
- 保持专业学术风格，避免口语化表达
- 内容应该是一份独立完整的学习材料，而非对话回复"""

    def _stream_api_call_openai(self, system_prompt, user_prompt):
        """
        使用OpenAI库进行流式API调用
        
        参数:
        - system_prompt: 系统提示
        - user_prompt: 用户提示
        
        返回:
        - 生成器对象，逐步yield优化后的笔记内容
        """
        try:
            # 添加超时控制
            timeout_seconds = 120  # 设置120秒超时
            start_time = time.time()
            
            response = self.client.chat.completions.create(
                model=self.model_name,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_prompt}
                ],
                stream=True,
                temperature=0.3,
                max_tokens=4096 # 调整为不超过4096的安全值
            )
            
            buffer = ""
            current_chunk = ""
            content_started = False
            last_yield_time = time.time()  # 记录上次yield时间
            buffer_threshold = 150  # 增加缓冲阈值，减少小数据传输
            time_threshold = 0.15  # 时间阈值，150毫秒
            
            # 用于追踪模型回复是否完成
            is_complete = False
            total_content = ""
            
            # 增加心跳机制，确保长时间生成时客户端不会断开
            last_heartbeat_time = time.time()
            heartbeat_interval = 10  # 10秒发送一次心跳
            
            for chunk in response:
                current_time = time.time()
                
                # 检查超时
                elapsed_time = current_time - start_time
                if elapsed_time > timeout_seconds:
                    logger.warning(f"流式API调用超时，已经运行 {elapsed_time:.1f} 秒")
                    if total_content:
                        # 如果已经有部分内容，返回它
                        note_content, ai_comments = self._separate_content_and_comments(total_content)
                        yield {
                            "complete": True,
                            "timeout": True,
                            "optimized_content": note_content,
                            "ai_comments": ai_comments
                        }
                    else:
                        # 如果完全没有内容，抛出异常以触发重试
                        raise TimeoutError(f"流式API调用超时，无内容返回，已运行 {elapsed_time:.1f} 秒")
                    return
                
                # 处理当前块
                delta = chunk.choices[0].delta
                delta_content = delta.content or ""
                
                # 合并内容
                if delta_content:
                    content_started = True
                    buffer += delta_content
                    current_chunk += delta_content
                    total_content += delta_content
                
                # 检查是否需要发送心跳
                if current_time - last_heartbeat_time >= heartbeat_interval:
                    yield {"heartbeat": True, "elapsed_seconds": elapsed_time}
                    last_heartbeat_time = current_time
                
                # 检查是否传输数据的时机
                time_since_last_yield = current_time - last_yield_time
                
                # 超过缓冲阈值或超过时间阈值时传输数据
                if (len(buffer) >= buffer_threshold or 
                    time_since_last_yield >= time_threshold) and buffer:
                    logger.debug(f"Yielding buffer of length {len(buffer)}")
                    last_yield_time = current_time
                    yield {"chunk": buffer, "optimized_content": total_content}
                    buffer = ""
                
                # 检查流式接口是否表示完成
                if chunk.choices[0].finish_reason is not None:
                    is_complete = True
                    if buffer:  # 最后的缓冲区数据
                        logger.debug(f"Yielding final buffer of length {len(buffer)}")
                        yield {"chunk": buffer, "optimized_content": total_content}
                        buffer = ""
                    
                    logger.info(f"Stream completed, total content length: {len(total_content)}")
                    
                    # 分离笔记内容和AI注释
                    note_content, ai_comments = self._separate_content_and_comments(total_content)
                    
                    # 后处理优化内容，移除无效字符，确保格式正确
                    note_content = self._post_process_content(note_content)
                    
                    # 返回完整内容
                    yield {
                        "complete": True,
                        "optimized_content": note_content,
                        "ai_comments": ai_comments
                    }
            
            # 以防万一流没有正常结束
            if not is_complete and buffer:
                logger.debug(f"Stream did not complete normally, yielding remaining buffer of length {len(buffer)}")
                yield {"chunk": buffer, "optimized_content": total_content}
                
                # 分离笔记内容和AI注释
                note_content, ai_comments = self._separate_content_and_comments(total_content)
                
                # 后处理优化内容
                note_content = self._post_process_content(note_content)
                
                # 返回最终完整内容
                yield {
                    "complete": True,
                    "optimized_content": note_content,
                    "ai_comments": ai_comments
                }
                
        except TimeoutError as e:
            # 针对超时错误的处理，重新抛出以便外层可以重试
            logger.error(f"流式API调用超时: {str(e)}")
            yield {"error": f"流式API调用超时，请稍后重试"}
            raise
        except Exception as e:
            error_msg = f"流式API调用失败: {str(e)}"
            logger.exception(error_msg)
            yield {"error": error_msg}
            # 重新抛出异常以便外层重试机制可以捕获
            raise
            
    def _post_process_content(self, content):
        """后处理生成的内容，清理可能的对话性语句和格式问题
        
        参数:
            content: 生成的内容
            
        返回:
            处理后的内容
        """
        if not content:
            return content
        
        import re
        
        # 清理常见对话式语句
        patterns_to_remove = [
            # 开头的对话式语句
            r'^(好的|这是|以下是|下面是|我将|我已经|我帮你|我可以|这里是|为你提供).*?\n',
            r'^(Here is|I have|I will|I can).*?\n',
            
            # 结尾的建议或总结
            r'\n(希望这对你有所帮助|希望这些信息对你有用|希望这能帮到你|如有任何问题|如果你有任何疑问).*?$',
            r'\n(建议你|你可以|对于大学生来说|值得注意的是).*?$',
            r'\n(I hope|Hope this helps|Let me know|Feel free).*?$',
            
            # 整段学习建议模式
            r'\n- \*\*理论学习\*\*：.*?(\n|$)',
            r'\n- \*\*实践应用\*\*：.*?(\n|$)',
            r'\n- \*\*问题诊断\*\*：.*?(\n|$)',
            r'\n-? (理论学习|实践应用|问题诊断)[：:](.*?)(\n|$)',
            
            # 应用场景建议段落
            r'\n建议(大学生|学生)在学习这些知识点时.*?$',
            r'\n对于大学生(来说)?，.*?$',
            r'\n在学习过程中，建议.*?$',
            r'在学习这些知识点时.*?$',
            r'通过(实验|实践|项目).*加深.*理解.*$',
            
            # 其他对话标记
            r'\*\*注意：\*\*.*?\n',
            r'\*\*提示：\*\*.*?\n',
            r'\*\*建议：\*\*.*?\n',
        ]
        
        # 应用清理模式
        cleaned_content = content
        for pattern in patterns_to_remove:
            cleaned_content = re.sub(pattern, '', cleaned_content, flags=re.IGNORECASE | re.MULTILINE)
        
        # 移除比较段落（常见于TCP与UDP的比较，后接建议）
        cleaned_content = re.sub(r'\n7\. \*\*TCP和UDP的比较\*\*：(.+?)(\n\n|$)', r'\n7. **TCP和UDP的比较**：\1\n', cleaned_content, flags=re.DOTALL)
        
        # 移除最后一段建议性质的内容（匹配模式更广泛）
        cleaned_content = re.sub(r'\n\n[^\n]*学习[^\n]*建议[^\n]*$', '', cleaned_content, flags=re.MULTILINE)
        cleaned_content = re.sub(r'\n\n[^\n]*学习.*$', '', cleaned_content, flags=re.MULTILINE)
        cleaned_content = re.sub(r'\n\n在.*?学习.*?中.*?$', '', cleaned_content, flags=re.MULTILINE)
        
        # 修复常见的Markdown格式问题
        # 确保标题前有空行
        cleaned_content = re.sub(r'([^\n])\n(#{1,6} )', r'\1\n\n\2', cleaned_content)
        
        # 确保列表项格式正确
        cleaned_content = re.sub(r'(\n[*\-+]) ([^\n]+)(?!\n)', r'\1 \2\n', cleaned_content)
        
        # 处理多余的空行
        cleaned_content = re.sub(r'\n{3,}', '\n\n', cleaned_content)
        
        return cleaned_content.strip()

    def _get_subject_expertise(self, subject_area=None):
        """
        根据学科领域返回相应的专业身份描述
        """
        if not subject_area:
            return "大学学习与笔记整理专家，精通多个学科领域的知识体系和教学方法"
        
        subject_expertise_map = {
            'math': "数学教育专家，精通高等数学、线性代数、概率统计等数学分支的知识体系和教学方法",
            'physics': "物理学教育专家，精通力学、电磁学、热力学、量子力学等物理学分支的知识体系和教学方法",
            'cs': "计算机科学教育专家，精通算法、数据结构、操作系统、数据库等计算机科学领域的知识体系和教学方法",
            'chemistry': "化学教育专家，精通有机化学、无机化学、物理化学等化学分支的知识体系和教学方法",
            'biology': "生物学教育专家，精通细胞生物学、分子生物学、生态学等生物学分支的知识体系和教学方法",
            'economics': "经济学教育专家，精通微观经济学、宏观经济学、计量经济学等经济学分支的知识体系和教学方法",
            'literature': "文学教育专家，精通文学理论、文学史、文本分析等文学研究方法和教学体系",
            'history': "历史学教育专家，精通中外历史、史学方法论、历史文献分析等历史学研究方法和教学体系",
            'philosophy': "哲学教育专家，精通逻辑学、形而上学、伦理学等哲学分支的知识体系和教学方法",
            'psychology': "心理学教育专家，精通认知心理学、发展心理学、社会心理学等心理学分支的知识体系和教学方法",
            'medicine': "医学教育专家，精通解剖学、生理学、病理学等医学基础和临床医学知识体系",
            'law': "法学教育专家，精通法理学、宪法学、民商法学等法学分支的知识体系和教学方法",
            'engineering': "工程教育专家，精通力学、材料学、控制理论等工程基础和专业知识体系",
            'language': "语言学教育专家，精通语音学、语法学、语义学等语言学分支的知识体系和教学方法",
            'database': "数据库系统专家，精通关系数据库理论、SQL查询优化、数据库设计范式、事务处理与并发控制、分布式数据库系统等核心知识，掌握Oracle、MySQL、PostgreSQL等主流数据库系统的架构特点和最佳实践"
        }
        
        return subject_expertise_map.get(subject_area, "大学学习与笔记整理专家，精通多个学科领域的知识体系和教学方法")

    def _get_subject_specific_prompts(self, subject_area, task_type):
        """
        返回针对特定学科的专门提示词
        """
        # 以下是特定学科的专门提示词示例，可以根据需要扩展
        specific_prompts = {
            'math': {
                'enrich': lambda note_content: f"""# 数学笔记内容丰富与完善任务

## 角色定位
你是资深数学教育专家，精通各类数学分支的知识体系和教学方法。你的任务是对数学课堂笔记进行专业化补充和完善，打造严谨、全面的数学学习资料。

## 专业处理原则
1. **数学严谨性**：
   - 确保所有定义、定理和公理表述的严格准确性
   - 明确数学符号的标准使用和含义
   - 补充必要的证明步骤和逻辑推导过程
   - 指明定理的适用条件和限制

2. **数学表达规范**：
   - 使用LaTeX格式呈现所有数学表达式，如：$\\frac{{d}}{{dx}}f(x)=\\lim_{{h\\to0}}\\frac{{f(x+h)-f(x)}}{{h}}$
   - 确保符号体系的一致性和标准性
   - 对复杂公式提供分步解释和直观理解
   - 使用精确的数学语言描述概念和关系

3. **思维方法培养**：
   - 展示数学思维过程和解题策略
   - 分析多种求解路径及其优劣比较
   - 提供启发式问题和思考方向
   - 指出常见思维误区和解题陷阱

4. **知识网络构建**：
   - 建立与先修知识和后续主题的连接
   - 指出不同数学分支间的关联和应用
   - 提供数学概念的实际应用示例
   - 构建完整的数学知识图谱

## 教学设计元素
1. **难度递进**：按照认知难度设计学习路径
2. **可视化辅助**：通过图形直观表达数学概念
3. **类比说明**：用类比帮助理解抽象概念
4. **练习设计**：提供针对性的练习和解析

## 输出格式要求
1. **使用标准Markdown语法**：
   - 确保所有标题、列表、表格、引用块和代码块格式正确
   - 使用正确的缩进和空行分隔各部分内容
   - 正确使用Markdown中的强调语法（*斜体*，**粗体**）

2. **简洁性与质量平衡**：
   - 保持文本简洁凝练，避免冗长阐述
   - 优先使用要点列表代替长段落
   - 重点突出核心概念和关键知识点
   - 确保在简化的同时不损失学术准确性和完整性

3. **内容组织**：
   - 仅输出笔记内容，不要包含额外的问候语或结束语
   - 不要添加"希望对你有帮助"、"祝学习愉快"等总结性语句
   - 专注于知识的呈现而非交流互动

## 待完善的数学笔记
{note_content}

请基于上述指南，对数学笔记进行专业、严谨、系统的完善，确保概念准确、逻辑严密、结构清晰，打造高质量的数学学习资料。输出时请确保使用标准Markdown格式，保持简洁性并专注于笔记内容本身。"""
            },
            'cs': {
                'enrich': lambda note_content: f"""# 计算机科学笔记内容丰富与完善任务

## 角色定位
你是资深计算机科学教育专家，精通算法、数据结构、编程语言、操作系统、数据库等计算机科学核心领域。你的任务是对计算机科学课堂笔记进行专业化补充和完善，打造理论与实践相结合的学习资料。

## 专业处理原则
1. **代码与算法展示**：
   - 提供关键算法的标准代码实现（使用代码块，注明语言）
   - 分析算法的时间复杂度和空间复杂度
   - 说明编程语言特性和最佳实践
   - 添加详细注释解释代码逻辑和关键步骤

2. **系统架构与设计原理**：
   - 补充系统架构图和流程图
   - 解释底层实现机制和设计模式
   - 分析技术选择的权衡和优化策略
   - 说明系统各组件间的交互关系

3. **技术演进与实践应用**：
   - 介绍技术的历史发展和演进路径
   - 对比新旧技术方案的差异和适用场景
   - 分析行业最佳实践和技术趋势
   - 提供真实世界中的应用案例

4. **实验与项目指导**：
   - 设计阶段性实验和项目练习
   - 提供测试数据和预期结果
   - 列举常见错误和调试技巧
   - 分享代码优化和性能提升方法

## 教学设计元素
1. **概念可视化**：使用图表展示抽象概念
2. **渐进式学习**：从基础到高级的知识递进
3. **交互性示例**：设计可交互的学习材料
4. **实战导向**：强调解决实际问题的能力

## 输出格式要求
1. **使用标准Markdown语法**：
   - 确保所有标题、列表、表格、引用块和代码块格式正确
   - 使用正确的缩进和空行分隔各部分内容
   - 正确使用Markdown中的强调语法（*斜体*，**粗体**）

2. **简洁性与质量平衡**：
   - 保持文本简洁凝练，避免冗长阐述
   - 优先使用要点列表代替长段落
   - 重点突出核心概念和关键知识点
   - 确保在简化的同时不损失学术准确性和完整性

3. **内容组织**：
   - 仅输出笔记内容，不要包含额外的问候语或结束语
   - 不要添加"希望对你有帮助"、"祝学习愉快"等总结性语句
   - 专注于知识的呈现而非交流互动

## 待完善的计算机科学笔记
{note_content}

请基于上述指南，对计算机科学笔记进行专业、系统、实用的完善，确保理论准确、示例丰富、实践导向，帮助学生建立扎实的计算机科学基础和应用能力。输出时请确保使用标准Markdown格式，保持简洁性并专注于笔记内容本身。"""
            },
            'database': {
                'enrich': lambda note_content: f"""# 数据库系统笔记内容丰富与完善任务

## 角色定位
你是资深数据库系统专家，精通关系数据库理论、SQL查询优化、数据库设计范式、事务处理与并发控制、分布式数据库系统等核心知识，同时具备Oracle、MySQL、PostgreSQL等主流数据库系统的实战经验。你的任务是对数据库课程笔记进行专业化补充和完善，打造理论与实践相结合的高质量学习资料。

## 专业处理原则
1. **概念精准诠释**：⭐
   - 提供数据库核心概念的学术精准定义，每个定义3-4句话
   - 阐明各种数据模型（关系模型、ER模型等）的严格数学表示
   - 解释数据库理论基础（关系代数、元组演算、域演算）
   - 使用标准术语表达，确保与教材和行业标准一致

2. **SQL语法与实践**：⭐⭐
   - 提供标准SQL语句的规范写法和执行过程
   - 展示复杂查询的优化思路和执行计划分析
   - 针对不同数据库管理系统的语法差异进行对比
   - 添加实用的SQL编写最佳实践和性能优化技巧

3. **数据库设计理论**：
   - 详细解释各级范式（1NF、2NF、3NF、BCNF、4NF、5NF）的定义和应用
   - 提供数据库模式设计的系统方法论
   - 分析反范式设计的适用场景和权衡
   - 补充ER图设计技巧和转换为关系模式的详细步骤

4. **事务处理与并发控制**：⭐⭐
   - 深入解析ACID属性的理论基础和实现机制
   - 对比各种并发控制方法（锁、时间戳、多版本并发控制）
   - 详细说明不同隔离级别的理论和实际影响
   - 提供事务管理的最佳实践和常见问题解决方案

5. **数据库系统架构**：
   - 解析数据库系统内部组件和工作原理
   - 说明存储结构、索引技术和查询处理流程
   - 分析数据库优化器的工作机制
   - 比较不同数据库产品的架构特点和适用场景

6. **新兴数据库技术**：
   - 介绍NoSQL、NewSQL等现代数据库系统及其应用
   - 分析分布式数据库的CAP理论和实现权衡
   - 解释内存数据库、时序数据库等特殊类型数据库的特点
   - 探讨区块链、大数据等技术与数据库系统的融合

## 教学设计元素
1. **考点标注**：⭐标识数据库课程考试重点和易错点
2. **案例分析**：提供数据库设计与应用的实际案例
3. **实验指导**：设计具体操作性实验步骤和预期结果
4. **常见错误分析**：指出常见概念混淆和实践误区

## 输出格式要求
1. **使用标准Markdown语法**：
   - 确保所有标题、列表、表格、代码块格式正确
   - 使用正确的缩进和空行分隔各部分内容
   - SQL代码使用代码块格式并标明语言

2. **结构化组织**：
   - 使用清晰的层次结构，从基础概念到高级应用
   - 重要内容使用要点列表呈现
   - 为复杂内容提供表格化呈现
   - 使用适当的小标题分隔不同主题

3. **学术准确性**：
   - 确保所有定义、公式和理论描述的学术准确性
   - 引用主流教材或论文中的标准表述
   - 避免使用模糊或含糊的表述
   - 保持术语使用的一致性

## 待完善的数据库笔记
{note_content}

请基于上述指南，对数据库系统笔记进行专业、系统、实用的完善，确保理论准确、实例丰富、应用导向，帮助大学生建立扎实的数据库理论基础和实践能力。请使用标准Markdown格式输出内容，保持专业性和简洁性，不添加任何问候语或结束语。""",
                'expand': lambda note_content: f"""# 数据库知识点扩展与深度解析任务

## 角色定位
你是资深数据库系统专家，精通关系数据库理论与实践，具备丰富的教学经验和企业实战背景。你的任务是对数据库核心知识点进行深度扩展和多维解析，打造深入而系统的学习资源。

## 知识深度解析框架
1. **概念本质分析**：⭐
   - 追溯概念的理论来源和发展历程
   - 阐明概念在数据库理论中的基础地位
   - 解析概念的数学原理和形式化表示
   - 标识考试必知概念（使用⭐标记）

2. **理论深度解构**：⭐⭐
   - 提供5-8句话的深入理论阐述
   - 展示数据库理论的严格数学推导
   - 解析理论局限性和适用条件
   - 连接相关理论形成知识网络

3. **技术实现剖析**：
   - 详细解释概念在数据库系统中的实现机制
   - 对比不同DBMS实现方式的差异（如Oracle、MySQL、PostgreSQL）
   - 分析实现方案的性能特点和资源消耗
   - 展示核心算法和数据结构的工作原理

4. **优化策略深度分析**：
   - 提供数据库设计和查询的专业优化方法
   - 解析优化技术背后的理论基础
   - 量化分析优化前后的性能差异
   - 提供循序渐进的优化案例教程

5. **应用能力培养**：⭐
   - 设计贴近实际的案例分析
   - 提供企业级数据库应用最佳实践
   - 分析实际项目中的数据库设计决策
   - 构建从理论到实践的完整知识路径

6. **前沿技术拓展**：
   - 介绍数据库领域的最新研究方向
   - 分析新兴数据库技术（如分布式数据库、时序数据库）
   - 探讨数据库与AI、大数据等技术的融合
   - 展望数据库技术的发展趋势

## 教学设计元素
1. **考点导航**：使用⭐符号标记重要考点，⭐⭐标记重难点
2. **知识图谱**：构建当前主题与其他知识点的关联图
3. **深度练习**：设计由浅入深的练习题，附详细解析
4. **案例驱动**：通过真实案例展示知识应用

## 输出格式要求
1. **使用标准Markdown语法**：
   - 确保所有标题、列表、表格、代码块格式正确
   - 使用正确的缩进和空行分隔各部分内容
   - SQL代码使用代码块格式并标明语言

2. **学术严谨性**：
   - 使用标准学术语言，避免口语化表述
   - 确保所有理论阐述的严格准确性
   - 适当引用权威文献或标准以支持论点
   - 保持术语使用的一致性和准确性

3. **内容深度与广度平衡**：
   - 理论深度：确保概念讲解深入本质
   - 应用广度：涵盖多种实际应用场景
   - 技术视角：包含多种数据库系统的特点
   - 发展视角：兼顾历史演进和未来趋势

## 待扩展的数据库笔记
{note_content}

请基于上述框架，对数据库知识点进行系统、深入、多维度的扩展与解析，打造一份既有理论深度又有实践指导价值的高质量学习资料。输出内容应当严格遵循标准Markdown格式，保持专业性和系统性，不添加问候语或结束语。"""
            }
            # 可以继续添加其他学科的特定提示词
        }
        
        if subject_area in specific_prompts and task_type in specific_prompts[subject_area]:
            # 获取提示词生成函数并传入当前处理的笔记内容
            prompt_func = specific_prompts[subject_area][task_type]
            return prompt_func(self._current_note_content)
        
        return None

    def _create_prompt_for_note_organization(self, note_content, task_type, subject_area, is_short_content=False, note_title=None):
        """创建适当的笔记组织提示词，根据任务类型和学科领域"""
        # 获取学科专家身份
        subject_expertise = self._get_subject_expertise(subject_area)
        
        # 获取特定学科提示词
        specific_prompts = self._get_subject_specific_prompts(subject_area, task_type)
        
        # 处理短内容的特殊提示
        short_content_emphasis = ""
        if is_short_content:
            original_content_str = f"「{note_content}」"
            short_content_emphasis = f"""
## 特别重要！原笔记内容极其简短
原始笔记内容非常简短：{original_content_str}

你必须严格遵循以下特殊要求：
1. 必须直接以原始内容「{note_content}」作为核心概念进行解释和扩展
2. 首先解释这个概念本身的含义和定义
3. 所有扩展内容必须直接与「{note_content}」相关，而不是生成通用学科知识
4. 避免偏离主题，不要生成与原始笔记无关的内容
5. 如果原笔记是缩写或术语，先解释它的完整含义，再进行扩展

原笔记标题：{note_title or '未提供'}
"""
        
        # 组装提示词
        if task_type == "enrich":
            prompt = f"""# {subject_area or '学科'}笔记知识深化与完善任务

## 专业定位
你是{subject_expertise}。你将以资深教育专家的身份，对大学生的学习笔记进行深度完善和知识点补充，帮助学生构建更完整的知识体系。

{short_content_emphasis}

## 知识体系构建原则
1. **基于原内容扩展**：⭐⭐
   - 必须保持原始笔记内容的核心概念和主题不变
   - 所有补充内容必须直接基于和延伸原始笔记中的概念
   - 不要引入与原笔记主题无关的内容
   - 确保补充内容与原笔记形成连贯的知识体系

2. **概念精确定义**：⭐
   - 为原笔记中的核心概念提供学术精准的定义（2-3句，引用权威来源）
   - 澄清概念间的区别、联系和层次关系
   - 纠正原笔记中的错误或不准确表述
   - 使用⭐标记考试重点概念和高频考点

3. **理论框架深化**：
   - 补充完整的理论背景和基础框架（4-6句话）
   - 阐明各理论要点之间的逻辑关系和发展脉络
   - 提供系统性的知识结构图或概念网络
   - 建立与先修和后续知识的连接点和桥梁

4. **方法论与解题策略**：
   - 提供系统化的问题解决路径和思维方法
   - 展示典型问题的多角度解题策略（从基础到进阶）
   - 分析解题关键点和常见误区（使用⚠️标识）
   - 设计思维引导型问题，促进深度思考能力

5. **考试应用导向**：⭐
   - 标记历年考试高频考点和重点知识（⭐表示）
   - 分类呈现常见题型及其系统解题思路
   - 提供针对性记忆方法、公式速查表和概念图
   - 设计符合考试形式的练习题和自测问题

6. **知识应用与实践**：
   - 提供学科知识在实际工作/研究中的应用案例（1-2个）
   - 展示概念或理论在解决实际问题中的运用方法
   - 补充与当前行业/科研前沿的技术发展关联
   - 设计微型项目或实践任务，强化应用能力

## 学习辅助工具
1. **知识地图**：为复杂知识点创建视觉化的概念关系图
2. **记忆框架**：提供结构化的记忆方法和关键点提取
3. **学习路径**：设计从基础到精通的阶段性学习指南
4. **自我检测**：创建理解检测点和自测问题（1-2个）
5. **资源导航**：推荐高质量的补充学习资料和工具

## 输出形式规范
1. **专业性保证**：
   - 使用学科标准术语和表达方式
   - 确保所有公式、定理的严格准确性
   - 遵循学术规范，必要时引用权威来源
   - 保持内容的逻辑一致性和完整性

2. **格式标准化**：
   - 严格遵循Markdown语法，确保结构清晰
   - 公式使用标准LaTeX格式，确保渲染正确
   - 代码使用适当的代码块和语法高亮
   - 图表说明完整，参考资料标注规范

3. **内容专注化**：
   - 直接输出优化后的笔记内容，无需问候语和结束语
   - 避免使用"希望对你有帮助"等非专业表述
   - 内容应自成体系，无需依赖对话上下文
   - 确保任何示例、案例都有教学价值

## 笔记原文
```
{note_content}
```

请基于以上指南，对笔记内容进行专业、系统的补充与深化，确保知识点准确、重点突出、结构清晰，既满足考试需求又支持长期能力发展，帮助大学生构建完整、深入的专业知识体系。"""
        elif task_type == "expand":
            prompt = f"""# {subject_area or '学科'}知识点深度解析与拓展任务

## 专业定位
你是{subject_expertise}。你将针对大学生笔记中的重要知识点，进行深度拓展和多维解析，帮助学生建立更深入、全面的学科理解和应用能力。

{short_content_emphasis}

## 知识深度解析框架
1. **原始内容为核心**：⭐⭐
   - 必须以原笔记中的概念或术语作为拓展的核心和起点
   - 所有解析必须直接围绕原笔记内容展开，保持主题一致性
   - 不要生成与原笔记内容无关的知识点或概念
   - 确保拓展内容是对原始概念的深化，而非偏离

2. **概念本质分析**：⭐
   - 揭示原笔记概念的核心本质、内在机制和理论基础
   - 追溯概念的学术来源、发展脉络和历史演进
   - 分析概念在学科知识体系中的定位和价值
   - 使用⭐标记核心概念和必考要点

3. **理论深度解构**：
   - 提供5-8句话的深入理论阐述和学术解析
   - 探讨理论的内在逻辑、推理过程和论证基础
   - 分析理论的适用条件、局限性和边界情况
   - 比较不同理论观点的异同点和优劣势

4. **方法论深度分析**：
   - 详细解析问题解决的系统方法和思维框架
   - 提供多角度的思考路径和策略选择依据
   - 分析方法应用的条件约束和最佳实践
   - 展示解决典型问题的完整思路和创新点

5. **知识整合与前沿拓展**：
   - 建立与相关知识点的多维联系网络和整合体系
   - 拓展至学科前沿动态和最新研究方向
   - 提供跨学科视角的关联分析和融合创新
   - 构建完整的知识图谱和发展脉络框架

6. **实践应用深化**：⭐
   - 设计典型案例分析（1-2例），展示理论实践转化
   - 提供在专业领域中的实际应用场景和解决方案
   - 分析该知识点在行业实践中的技术实现和挑战
   - 探讨知识应用的创新可能性和发展前景

## 多维度价值提升
1. **学术价值层**：
   - 与研究生入学考试重点知识对接
   - 为学术研究和论文写作奠定基础
   - 培养学科思维和批判性分析能力

2. **职业价值层**：
   - 直接链接至行业需求的核心能力
   - 提供真实工作场景中的应用案例
   - 对接专业认证和技能评估标准

3. **认知发展层**：
   - 引导从知识记忆向创新应用的思维跃升
   - 培养跨学科思考和问题解决能力
   - 建立终身学习所需的知识组织框架

## 学习辅助设计
1. **深度问题引导**：设计2-3个促进深层思考的问题
2. **知识联系图谱**：可视化呈现概念间的关联网络
3. **学习路径规划**：提供从基础到高阶的学习进阶路径
4. **理解检测点**：设置关键概念的自我检验点
5. **拓展资源导航**：推荐专业文献和进阶学习资源

## 输出形式规范
1. **学术严谨性**：
   - 使用标准学术语言，避免口语化表述
   - 确保所有理论阐述的严格准确性
   - 适当引用权威文献或标准以支持论点
   - 保持术语使用的一致性和专业性

2. **结构清晰性**：
   - 使用多级标题建立清晰的知识层次
   - 通过要点列表提高内容可读性
   - 合理使用表格整合比较性内容
   - 适当添加图示辅助复杂概念理解

3. **内容专注性**：
   - 直接输出优化后的笔记内容，无需问候语
   - 避免使用"希望有帮助"等非学术表述
   - 内容应自成体系，无需依赖对话上下文
   - 确保内容既有深度又便于学习理解

## 笔记原文
```
{note_content}
```

请基于上述框架，对笔记中的关键知识点进行系统、深入、多维度的扩展与解析，打造既有理论深度又有实践指导价值的高质量学习资料，帮助大学生建立更深层次的学科理解和应用能力。"""
        else:
            # 通用提示词模板
            prompt = f"""# {subject_area or '学科'}笔记专业优化任务
            
## 专业定位
你是{subject_expertise}。你的任务是{"丰富和完善" if task_type == "enrich" else "扩展和深化"} 大学生的学习笔记，使其成为专业、系统、可操作的学习资源。

{short_content_emphasis}

## 优化核心原则
1. **原始内容为核心**：必须以原笔记内容为基础进行优化，保持主题一致性
2. **知识精确性**：确保学术概念定义准确，理论阐述严谨
3. **结构系统性**：建立清晰的知识层次和逻辑关联
4. **重点突出性**：使用⭐标记考点和关键概念
5. **应用导向性**：添加实践案例和应用场景
6. **学习辅助性**：提供记忆方法和自测问题

## 专业呈现要求
1. 使用标准Markdown语法组织内容
2. 数学公式使用LaTeX格式正确表达
3. 概念定义学术准确且简洁明了
4. 内容深度和广度适合大学学习阶段
5. 直接输出优化内容，不添加任何问候语或结束语

## 待优化笔记内容
```
{note_content}
```

请基于以上指南，对笔记进行专业、系统的优化，确保理论准确、结构清晰、重点突出，帮助大学生建立完整的学科知识体系和应用能力。"""

        # 添加特定学科的提示词，如果有的话
        if specific_prompts:
            # 如果是短内容，仍然添加特殊提示
            if is_short_content and "原笔记内容极其简短" not in specific_prompts:
                specific_prompts = specific_prompts.replace("## 待完善的", f"{short_content_emphasis}\n\n## 待完善的")
            prompt = specific_prompts

        # 针对短内容（如"acid"）的特殊处理
        if is_short_content and note_title and subject_area == 'database' and note_content.lower() == "acid":
            prompt = f"""# 数据库ACID特性专项解析任务

## 专业定位
你是资深数据库系统专家，精通关系数据库理论与实践。你的任务是围绕数据库事务的ACID特性进行专业、深入的解析。

## 特别强调
原始笔记内容仅为"acid"，笔记标题为"{note_title}"。请特别注意：
1. 必须专注于ACID（原子性、一致性、隔离性、持久性）作为核心概念
2. 解析必须严格围绕ACID特性展开，不要偏离主题
3. 不要生成与ACID无关的数据库通用知识
4. 内容必须具有学术准确性和教学价值

## ACID特性解析框架
1. **核心定义与概述**：⭐
   - 提供ACID完整准确的学术定义
   - 解释ACID在事务处理中的基础地位
   - 阐明ACID对数据库系统的重要意义
   - 简述ACID特性的历史发展背景

2. **各特性深度解析**：⭐⭐
   - Atomicity（原子性）：定义、实现机制、违反后果
   - Consistency（一致性）：定义、约束类型、保证方法
   - Isolation（隔离性）：定义、隔离级别、实现技术
   - Durability（持久性）：定义、实现方法、恢复机制

3. **实现机制详解**：
   - 日志机制与ACID的关系
   - 锁机制与ACID的关系
   - 多版本并发控制与ACID
   - 缓冲池管理与ACID

4. **不同隔离级别与ACID**：⭐
   - 未提交读(Read Uncommitted)
   - 已提交读(Read Committed)
   - 可重复读(Repeatable Read)
   - 可串行化(Serializable)
   - 各级别对ACID特性的保证程度

5. **ACID在主流数据库系统中的实现**：
   - MySQL/InnoDB的ACID实现特点
   - PostgreSQL的ACID实现特点
   - Oracle的ACID实现特点
   - SQL Server的ACID实现特点

6. **ACID的权衡与挑战**：
   - ACID与性能之间的权衡
   - 分布式系统中的ACID挑战
   - BASE模型与ACID的对比
   - 当代数据库系统对ACID的调整与优化

## 学习辅助工具
1. **考点标识**：使用⭐标记ACID相关考试重点
2. **图示说明**：提供ACID各特性的可视化表示
3. **案例分析**：设计1-2个展示ACID重要性的案例
4. **自测问题**：设计3-5个测试ACID理解的问题

## 输出要求
1. 必须使用标准Markdown格式
2. 保持内容的学术严谨性和专业性
3. 直接输出笔记内容，不加任何问候语或结束语
4. 确保内容既有理论深度，又便于学习理解

请基于以上框架，生成一份关于数据库ACID特性的专业学习笔记，帮助数据库课程学习者深入理解这一核心概念。"""

        return prompt

    def _process_long_content(self, note_content, task_type, subject_area, note_title=None):
        """
        处理较长的笔记内容，采用分段处理后流式返回
        
        参数:
        - note_content: 原始笔记内容
        - task_type: 任务类型
        - subject_area: 学科领域
        - note_title: 笔记标题，用于辅助推断学科
        
        返回:
        - 生成器，流式返回处理结果
        """
        try:
            # 分段处理，每段不超过3000字符
            segments = self._split_content(note_content, max_length=3000)
            logger.info(f"将长文本分为{len(segments)}段进行处理")
            
            # 存储所有分段处理结果
            total_content = ""
            current_segment = 1
            total_segments = len(segments)
            
            # 如果未指定学科领域且有笔记标题，尝试推断
            if not subject_area and note_title:
                subject_area = self._detect_subject_area("", note_title)
                logger.info(f"通过标题推断学科领域: {subject_area}")
            
            # 处理每个分段
            for segment in segments:
                logger.info(f"开始处理第{current_segment}/{total_segments}段")
                
                # 构建分段处理提示
                segment_prompt = self._create_prompt_for_segment(
                    f"这是原始笔记的第{current_segment}部分（共{total_segments}部分）。\n\n{segment}", 
                    task_type, 
                    subject_area
                )
                
                # 设置系统提示
                system_prompt = "你是帮助大学生学习的专业的笔记整理工具，不是对话助手。你的输出必须严格遵循标准Markdown语法，不加入任何问候、祝福或总结性语句。直接输出整理后的笔记内容，保持专业、简洁和结构化的风格。严禁在笔记结尾添加'希望本笔记对你有帮助'、'以上是整理的内容'等总结性语句。"
                
                # 调用API处理当前分段
                segment_result = ""
                
                try:
                    # 创建流式调用
                    response = self.client.chat.completions.create(
                        model=self.model_name,
                        messages=[
                            {"role": "system", "content": system_prompt},
                            {"role": "user", "content": segment_prompt}
                        ],
                        stream=True,
                        temperature=0.5,
                        max_tokens=4000
                    )
                    
                    # 处理流式响应
                    buffer = ""
                    segment_content = ""
                    
                    # 向调用者流式返回段落处理进度
                    yield {"chunk": f"\n\n## 正在处理第{current_segment}/{total_segments}段...\n\n", "is_progress": True}
                    
                    # 处理流式响应
                    for chunk in response:
                        if hasattr(chunk.choices[0].delta, 'content') and chunk.choices[0].delta.content:
                            content = chunk.choices[0].delta.content
                            buffer += content
                            segment_content += content
                            
                            # 当缓冲区达到一定大小时返回
                            if len(buffer) >= 100:
                                yield {"chunk": buffer, "is_segment": True, "segment_num": current_segment}
                                buffer = ""
                    
                    # 处理剩余的缓冲区
                    if buffer:
                        yield {"chunk": buffer, "is_segment": True, "segment_num": current_segment}
                    
                    # 更新总内容
                    segment_result = segment_content
                    
                except Exception as e:
                    logger.error(f"处理第{current_segment}段时出错: {str(e)}")
                    yield {"error": f"处理第{current_segment}段时出错: {str(e)}"}
                    continue
                
                # 合并结果到总内容
                if current_segment > 1:
                    # 对非第一段，尝试去除可能重复的标题
                    lines = segment_result.split("\n")
                    non_title_start = 0
                    
                    for i, line in enumerate(lines):
                        if not line.strip().startswith("#"):
                            non_title_start = i
                            break
                    
                    segment_result = "\n".join(lines[non_title_start:])
                
                total_content += (segment_result + "\n\n")
                current_segment += 1
            
            # 流式处理完成后，分离内容和AI评论
            final_content, ai_comments = self._separate_content_and_comments(total_content)
            
            # 返回完整内容
            yield {
                "complete": True,
                "optimized_content": final_content,
                "ai_comments": ai_comments
            }
            
        except Exception as e:
            logger.exception(f"长文本处理失败: {str(e)}")
            yield {"error": f"长文本处理失败: {str(e)}"}
            
    def _split_content(self, content, max_length=3000):
        """
        将内容分割成多个片段，尽量在自然段落处分割
        """
        if len(content) <= max_length:
            return [content]
            
        segments = []
        current_pos = 0
        
        while current_pos < len(content):
            # 如果剩余内容不足max_length，直接作为最后一段
            if current_pos + max_length >= len(content):
                segments.append(content[current_pos:])
                break
            
            # 尝试在自然段落处分割
            split_pos = content.rfind("\n\n", current_pos, current_pos + max_length)
            
            # 如果找不到双换行，尝试单换行
            if split_pos == -1:
                split_pos = content.rfind("\n", current_pos, current_pos + max_length)
            
            # 如果还找不到，就在单词边界分割
            if split_pos == -1:
                split_pos = content.rfind(" ", current_pos, current_pos + max_length)
            
            # 如果所有尝试都失败，就强制分割
            if split_pos == -1:
                split_pos = current_pos + max_length
            
            segments.append(content[current_pos:split_pos])
            current_pos = split_pos + 1
        
        return segments
    
    def _separate_content_and_comments(self, full_text):
        """
        将API响应内容分离为笔记内容和AI评论，基于常见模式
        """
        # 常见的结束模式，表示AI评论或总结的开始
        ending_patterns = [
            "希望这份", "通过以上", "总结：", "总结:", "小结：", "小结:", 
            "这些就是", "以上是", "这是我为您", "这是我为你",
            "希望对你", "希望对您", "我已经", "祝你学习愉快", 
            "希望能帮助到你", "希望能帮助到您", "这样的笔记", 
            "这份笔记", "这些笔记", "以上内容"
        ]
        
        # 检查常见结束模式
        for pattern in ending_patterns:
            if pattern in full_text:
                parts = full_text.split(pattern, 1)
                if len(parts) == 2:
                    return parts[0].strip(), pattern + parts[1]
        
        # 如果没有找到常见模式，尝试检查最后一段是否为总结
        paragraphs = full_text.split('\n\n')
        if len(paragraphs) > 1:
            last_paragraph = paragraphs[-1].lower()
            summary_indicators = ["总结", "小结", "希望", "帮助", "学习"]
            
            if any(indicator in last_paragraph for indicator in summary_indicators):
                return '\n\n'.join(paragraphs[:-1]), paragraphs[-1]
        
        # 移除一些常见的结束语
        content = full_text
        common_endings = [
            "希望这对你有所帮助！", "祝学习顺利！", "希望对您有所帮助！",
            "祝您学习愉快！", "加油！", "希望能帮到你！"
        ]
        
        for ending in common_endings:
            if content.endswith(ending):
                content = content[:-len(ending)].strip()
        
        return content, ""
    
    def _check_buffer_for_summary(self, buffer):
        """
        检查缓冲区中是否包含总结性标记，用于分离笔记内容和AI评论
        
        返回:
        - 是否找到总结标记
        """
        # 常见的AI评论开始标记
        summary_markers = [
            "希望这份", "希望这些", "希望这个", "希望以上", 
            "这份笔记", "这些笔记", "这些内容", 
            "以上是", "总结：", "总结:", 
            "祝你学习顺利", "祝学习顺利"
        ]
        
        # 检查是否包含任何总结标记
        for marker in summary_markers:
            if marker in buffer:
                return True
                
        return False

    def _create_prompt_for_segment(self, segment_content, task_type, subject_area):
        """
        为分段处理创建专门的提示词
        """
        # 获取学科专家身份
        subject_expertise = self._get_subject_expertise(subject_area)
        
        segment_type_desc = {
            'enrich': "知识深化与完善",
            'expand': "概念深度解析"
        }
        
        type_desc = segment_type_desc.get(task_type, "专业优化")
        
        subject_desc = f"关于{subject_area}学科的" if subject_area else ""
        
        return f"""# 笔记分段{type_desc}任务

## 专业定位
你是{subject_expertise}。你的任务是对笔记分段内容进行专业{type_desc}处理。

## 处理核心要求
这是{subject_desc}笔记的一个分段，需要进行{type_desc}。请遵循以下原则：
1. **专业准确性**：确保学术概念和理论表述的精确性
2. **知识体系性**：建立与其他分段的知识连贯性和体系完整性
3. **重点标识**：使用⭐标记关键概念和考试重点
4. **结构优化**：采用层次清晰的标题结构和逻辑组织
5. **深度平衡**：根据内容重要性调整解析深度，避免喧宾夺主

## 格式与内容规范
1. **Markdown标准化**：
   - 严格使用标准Markdown语法格式化内容
   - 正确使用标题层级、列表、表格等元素
   - 确保公式使用标准LaTeX格式正确呈现
   - 代码块需标明语言类型以启用语法高亮

2. **学术专业化**：
   - 使用学科专业术语和标准表达
   - 确保所有概念定义和理论描述的准确性
   - 保持术语使用的一致性和专业性
   - 避免口语化或简化过度的表述

3. **内容自成体系**：
   - 不需要添加开头的大标题，直接处理内容
   - 与其他分段保持衔接但又相对独立
   - 不添加任何问候语、结束语或总结性语句
   - 直接输出优化后的专业笔记内容

## 待处理的笔记分段内容：
{segment_content}

请根据上述要求进行专业{type_desc}，输出内容应当严格遵循学术规范和Markdown格式，确保专业质量和知识的连贯性。"""

    def _sanitize_input(self, content):
        """
        清理和验证输入内容
        """
        if not content:
            return ""
            
        # 移除可能的特殊字符和控制符
        content = re.sub(r'[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]', '', content)
        
        # 限制长度，防止超长文本
        max_safe_length = 100000  # 10万字符上限
        if len(content) > max_safe_length:
            logger.warning(f"输入内容过长({len(content)}字符)，已截断至{max_safe_length}字符")
            content = content[:max_safe_length]
            
        return content.strip()
        
    def _perform_health_check_if_needed(self):
        """
        定期执行健康检查
        """
        current_time = time.time()
        if current_time - self.last_health_check > self.health_check_interval:
            try:
                # 简单的API连通性测试
                response = self.client.chat.completions.create(
                    model=self.model_name,
                    messages=[
                        {"role": "system", "content": "You are a helpful assistant."},
                        {"role": "user", "content": "hello"}
                    ],
                    max_tokens=10
                )
                self.is_healthy = True
                logger.info("API健康检查成功")
            except Exception as e:
                self.is_healthy = False
                logger.error(f"API健康检查失败: {str(e)}")
                
            self.last_health_check = current_time
              
    def _fallback_processing(self, note_content, task_type, subject_area, note_title=None):
        """
        当主要处理方式失败时的备用处理逻辑
        
        参数:
        - note_content: 原始笔记内容
        - task_type: 任务类型
        - subject_area: 学科领域
        - note_title: 笔记标题，用于辅助推断学科
        """
        try:
            # 如果未指定学科领域且有笔记标题，尝试推断
            if not subject_area and note_title:
                subject_area = self._detect_subject_area("", note_title)
                logger.info(f"备用处理中通过标题推断学科领域: {subject_area}")
                
            # 构建简化的系统提示
            system_prompt = "你是一个专业的笔记优化助手。请优化以下笔记内容，使其更加清晰、准确和有结构。不要添加任何问候语或结束语。"
            
            # 构建简化的用户提示
            title_info = f"（标题：{note_title}）" if note_title else ""
            user_prompt = f"请对以下{subject_area or ''}学科的笔记{title_info}进行{task_type}优化：\n\n{note_content}"
            
            # 使用更简单的处理方式，不进行复杂的提示词构建
            response = self.client.chat.completions.create(
                model=self.model_name,
                messages=[
                    {"role": "system", "content": system_prompt},
                    {"role": "user", "content": user_prompt}
                ],
                temperature=0.3,
                max_tokens=4000
            )
            
            # 返回处理结果
            optimized_content = response.choices[0].message.content
            note_content, ai_comments = self._separate_content_and_comments(optimized_content)
            
            return {
                "complete": True,
                "optimized_content": note_content,
                "ai_comments": ai_comments,
                "fallback_mode": True
            }
            
        except Exception as e:
            logger.exception(f"备用处理也失败: {str(e)}")
            # 如果备用处理也失败，返回原始内容和错误信息
            return {
                "complete": True,
                "optimized_content": note_content,
                "error": f"笔记优化失败: {str(e)}",
                "fallback_mode": True
            }

    def _detect_subject_area(self, note_content, note_title=None):
        """
        从笔记标题和内容中推断学科领域
        
        参数:
        - note_content: 笔记内容
        - note_title: 笔记标题
        
        返回:
        - 推断的学科领域代码，如'math', 'cs', 'physics'等
        """
        # 定义学科关键词映射
        subject_keywords = {
            'math': ['数学', '微积分', '线性代数', '概率', '统计', '几何', '代数', '微分', '积分', '方程', '函数', '极限', '导数', 'calculus', 'algebra', 'probability', 'statistics', 'geometry', 'equation'],
            'physics': ['物理', '力学', '热力学', '电磁学', '光学', '量子', '相对论', '牛顿', '能量', '功率', '电场', '磁场', 'physics', 'mechanics', 'thermodynamics', 'quantum', 'relativity', 'newton', 'energy'],
            'cs': ['计算机', '算法', '数据结构', '编程', '程序', '软件', '网络', '操作系统', '数据库', 'SQL', 'NoSQL', '人工智能', '机器学习', 'python', 'java', 'c++', 'javascript', 'html', 'css', 'computer science', 'algorithm', 'programming', 'software', 'network', 'operating system'],
            'database': ['数据库', '关系数据库', 'SQL', 'NoSQL', '事务', 'ACID', '索引', '查询', '存储过程', '触发器', '范式', '主键', '外键', '表', '连接', '事务隔离', '并发控制', 'database', 'relation', 'transaction', 'index', 'query', 'trigger', 'normalization', 'primary key', 'foreign key', 'table', 'join'],
            'chemistry': ['化学', '有机', '无机', '物理化学', '分子', '原子', '化合物', '元素', '反应', '催化', '氧化', '还原', '酸', '碱', '盐', 'chemistry', 'organic', 'inorganic', 'molecular', 'atomic', 'compound', 'element', 'reaction', 'catalyst', 'oxidation', 'acid', 'base', 'salt'],
            'biology': ['生物', '细胞', '分子', '基因', '蛋白质', 'DNA', 'RNA', '遗传', '进化', '生态', '光合作用', '呼吸', '生物多样性', 'biology', 'cell', 'molecular', 'gene', 'protein', 'genetic', 'evolution', 'ecology', 'photosynthesis', 'respiration'],
            'economics': ['经济', '微观', '宏观', '市场', '供需', '价格', '通货膨胀', '失业率', '汇率', '货币政策', '财政政策', '博弈论', 'economics', 'microeconomics', 'macroeconomics', 'market', 'supply and demand', 'price', 'inflation', 'unemployment', 'exchange rate'],
            'literature': ['文学', '小说', '诗歌', '散文', '戏剧', '文体', '修辞', '意象', '象征', '比喻', '文艺复兴', '浪漫主义', '现实主义', 'literature', 'novel', 'poetry', 'prose', 'drama', 'rhetoric', 'imagery', 'symbolism', 'metaphor'],
            'history': ['历史', '朝代', '古代', '近代', '现代', '革命', '战争', '文明', '遗址', '考古', '文物', '史学', 'history', 'dynasty', 'ancient', 'modern', 'revolution', 'war', 'civilization', 'archaeology'],
            'philosophy': ['哲学', '形而上学', '认识论', '伦理学', '逻辑学', '美学', '存在', '本体', '意识', '理性', '道德', '辩证法', 'philosophy', 'metaphysics', 'epistemology', 'ethics', 'logic', 'aesthetics', 'existence', 'consciousness'],
            'psychology': ['心理', '认知', '行为', '情绪', '感知', '记忆', '学习', '动机', '人格', '发展', '社会心理', '变态心理', 'psychology', 'cognitive', 'behavioral', 'emotion', 'perception', 'memory', 'learning', 'motivation'],
            'medicine': ['医学', '解剖', '生理', '病理', '药理', '治疗', '诊断', '预防', '手术', '临床', '疾病', '症状', 'medicine', 'anatomy', 'physiology', 'pathology', 'pharmacology', 'therapy', 'diagnosis', 'prevention', 'surgery', 'clinical'],
            'law': ['法律', '宪法', '民法', '刑法', '行政法', '商法', '经济法', '国际法', '知识产权', '合同', '侵权', '诉讼', 'law', 'constitution', 'civil law', 'criminal law', 'administrative law', 'commercial law', 'international law', 'intellectual property'],
            'engineering': ['工程', '机械', '电气', '土木', '化工', '材料', '力学', '结构', '控制', '自动化', '测量', '设计', 'engineering', 'mechanical', 'electrical', 'civil', 'chemical', 'material', 'structure', 'control', 'automation', 'measurement', 'design'],
            'language': ['语言', '语音', '语法', '语义', '词汇', '句法', '音韵', '修辞', '翻译', '外语', '方言', 'language', 'phonetics', 'grammar', 'semantics', 'vocabulary', 'syntax', 'rhetoric', 'translation', 'foreign language', 'dialect']
        }
        
        # 专业术语和缩写对应表（根据需要可以继续扩充）
        term_to_subject = {
            # 数据库缩写和术语
            'acid': 'database',
            'sql': 'database',
            'nosql': 'database',
            'crud': 'database',
            'rdbms': 'database',
            'oltp': 'database',
            'olap': 'database',
            'etl': 'database',
            'er': 'database',  # Entity-Relationship
            'ddl': 'database',
            'dml': 'database',
            'dcl': 'database',
            'join': 'database',
            'transaction': 'database',
            
            # 计算机科学缩写和术语
            'oop': 'cs',
            'tcp': 'cs',
            'ip': 'cs',
            'http': 'cs',
            'api': 'cs',
            'gui': 'cs',
            'os': 'cs',
            'ide': 'cs',
            'sdk': 'cs',
            'cdn': 'cs',
            'mvc': 'cs',
            'orm': 'cs',
            'url': 'cs',
            'json': 'cs',
            'xml': 'cs',
            'css': 'cs',
            'html': 'cs',
            
            # 数学缩写和术语
            'ode': 'math',  # Ordinary Differential Equation
            'pde': 'math',  # Partial Differential Equation
            'svd': 'math',  # Singular Value Decomposition
            'pca': 'math',  # Principal Component Analysis
            'eigen': 'math',
            'matrix': 'math',
            'vector': 'math',
            'theorem': 'math',
            'lemma': 'math',
            
            # 物理缩写和术语
            'mhd': 'physics',
            'qed': 'physics',
            'qcd': 'physics',
            'joule': 'physics',
            'newton': 'physics',
            'tesla': 'physics',
            'farad': 'physics',
            'maxwell': 'physics',
            
            # 化学缩写和术语
            'ph': 'chemistry',
            'nacl': 'chemistry',
            'h2o': 'chemistry',
            'co2': 'chemistry',
            'nh3': 'chemistry',
            'h2so4': 'chemistry',
            
            # 生物学缩写和术语
            'dna': 'biology',
            'rna': 'biology',
            'atp': 'biology',
            'mrna': 'biology',
            'pcr': 'biology',
            'crispr': 'biology',
            
            # 经济学缩写和术语
            'gdp': 'economics',
            'cpi': 'economics',
            'ppp': 'economics',
            'roi': 'economics',
            'esg': 'economics'
        }
        
        # 用于保存每个学科的匹配分数
        subject_scores = {subject: 0 for subject in subject_keywords}
        
        # 先检查是否是一个短内容且匹配专业术语或缩写
        if note_content and len(note_content.strip()) < 30:
            content_lower = note_content.lower().strip()
            
            # 精确匹配专业术语或缩写
            if content_lower in term_to_subject:
                subject = term_to_subject[content_lower]
                logger.info(f"通过专业术语或缩写 '{content_lower}' 直接识别为 {subject} 领域")
                return subject
            
            # 如果内容是多个单词，尝试匹配其中任一单词
            words = content_lower.split()
            for word in words:
                if word in term_to_subject:
                    subject = term_to_subject[word]
                    logger.info(f"通过内容中的术语 '{word}' 识别为 {subject} 领域")
                    subject_scores[subject] += 15
        
        # 先从标题中识别学科（标题权重更高）
        if note_title:
            title_text = note_title.lower()
            # 直接匹配学科名称（最高权重）
            for subject, keywords in subject_keywords.items():
                # 检查标题是否直接包含学科名称
                if any(keyword in title_text for keyword in keywords[:2]):
                    subject_scores[subject] += 10
                
                # 检查标题中的其他关键词
                for keyword in keywords:
                    if keyword in title_text:
                        subject_scores[subject] += 3
            
            # 检查标题中是否包含专业术语或缩写
            for term, subject in term_to_subject.items():
                if term in title_text:
                    subject_scores[subject] += 8
                    
            # 特殊处理一些常见的标题模式
            if '数据库' in title_text or 'database' in title_text:
                subject_scores['database'] += 15
                subject_scores['cs'] += 5
            
            if '计算机' in title_text or 'computer' in title_text:
                subject_scores['cs'] += 15
            
            # 检查特定课程名称
            course_mappings = {
                '高等数学': 'math',
                '线性代数': 'math',
                '概率统计': 'math',
                '大学物理': 'physics',
                '数据结构': 'cs',
                '算法': 'cs',
                '操作系统': 'cs',
                '数据库系统': 'database',
                '数据库原理': 'database',
                '有机化学': 'chemistry',
                '分子生物学': 'biology',
                '微观经济学': 'economics',
                '宏观经济学': 'economics',
                '中国文学': 'literature',
                '外国文学': 'literature',
                '中国历史': 'history',
                '世界历史': 'history',
                '西方哲学': 'philosophy',
                '认知心理学': 'psychology',
                '临床医学': 'medicine',
                '宪法学': 'law',
                '机械工程': 'engineering',
                '电气工程': 'engineering',
                '语言学概论': 'language'
            }
            
            for course, subject in course_mappings.items():
                if course in title_text:
                    subject_scores[subject] += 20  # 课程名称匹配给予最高权重
        
        # 从内容中识别学科（如果内容不为空）
        if note_content and len(note_content) > 3:  # 确保内容至少有一些字符
            content_text = note_content.lower()
            
            # 针对特殊情况：很短的内容
            if len(content_text) < 30:
                # 检查专业术语或缩写
                for term, subject in term_to_subject.items():
                    if term in content_text.split():  # 确保是一个完整的单词
                        subject_scores[subject] += 12
                        logger.info(f"短内容中找到专业术语: {term} -> {subject}")
                
                # 特殊处理一些可能的多词组合
                if note_title:
                    title_keywords = ' '.join([
                        k for k in subject_keywords.keys() 
                        if any(kw in note_title.lower() for kw in subject_keywords[k][:3])
                    ])
                    
                    if title_keywords:
                        logger.info(f"从标题中检测到可能的学科关键词: {title_keywords}")
                        
                        # 针对数据库特殊处理
                        if ('数据库' in note_title or 'database' in note_title.lower()) and content_text.strip() == 'acid':
                            subject_scores['database'] += 25
                            logger.info("标题包含'数据库'且内容为'acid'，强烈倾向于数据库学科")
            else:
                # 常规内容分析
                for subject, keywords in subject_keywords.items():
                    for keyword in keywords:
                        if keyword in content_text:
                            subject_scores[subject] += 1
                            
                # 检查特定术语和概念
                specific_terms = {
                    'algorithm': 'cs',
                    'data structure': 'cs',
                    'programming': 'cs',
                    'software': 'cs',
                    'network': 'cs',
                    'operating system': 'cs',
                    'database': 'database',
                    'sql': 'database',
                    'transaction': 'database',
                    'acid': 'database',  # 数据库中的ACID属性
                    'relativity': 'physics',
                    'quantum': 'physics',
                    'derivative': 'math',
                    'integral': 'math',
                    'matrix': 'math',
                    'chemical': 'chemistry',
                    'molecule': 'chemistry',
                    'cell': 'biology',
                    'dna': 'biology',
                    'market': 'economics',
                    'inflation': 'economics',
                    'novel': 'literature',
                    'poetry': 'literature',
                    'dynasty': 'history',
                    'war': 'history',
                    'ethics': 'philosophy',
                    'consciousness': 'philosophy',
                    'cognitive': 'psychology',
                    'behavior': 'psychology',
                    'diagnosis': 'medicine',
                    'treatment': 'medicine',
                    'constitution': 'law',
                    'contract': 'law',
                    'structure': 'engineering',
                    'design': 'engineering',
                    'grammar': 'language',
                    'syntax': 'language'
                }
                
                for term, subject in specific_terms.items():
                    if term in content_text:
                        subject_scores[subject] += 2
        
        # 找出得分最高的学科
        best_subject = max(subject_scores.items(), key=lambda x: x[1])
        
        # 如果最高分太低（小于3），返回通用学科（None）
        if best_subject[1] < 3:
            logger.info(f"无法确定学科领域，最高得分为 {best_subject[1]} (学科: {best_subject[0]})")
            return None
        
        logger.info(f"推断学科领域: {best_subject[0]}，得分: {best_subject[1]}")
        return best_subject[0]
